package xml;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import modele.Balade;
import modele.Docs;
import modele.Noeud;
import modele.Terme;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import parsage.Lemmatiseur;
import bdd.RemplirBDD;

/**
 * 
 * @author Florence Delrieu & Coralie Micouin
 * 
 */
/*
 */
public class ParseJDomDoc {

	/**
	 * Construit les arraylists a partir des fichiers XML
	 */
	public static Balade parseXmlToJava(String path) {
		Balade b = new Balade();
		ArrayList<Noeud> noeuds = new ArrayList<Noeud>();
		ArrayList<Terme> termes = new ArrayList<Terme>();
		ArrayList<Docs> documents = new ArrayList<Docs>();
		Map<String, List<String>> mapTitres = new HashMap<String, List<String>>();
		Map<String, List<String>> mapSsTitres = new HashMap<String, List<String>>();

		// Le repertoire des balades : ./ressources/Collection
		File ressources = new File(path);
		int idDocument = 0;
		// Pour chaque fichier dans ce repertoire :
		for (File fichier : ressources.listFiles()) {
			// On ne conserve que les fichiers xml
			if (fichier.getAbsolutePath().endsWith(".xml")) {
//				System.out.println("fichier courant = "
//						+ fichier.getAbsolutePath());

				DocumentBuilderFactory factory = DocumentBuilderFactory
						.newInstance();

				DocumentBuilder docBuilder;

				Document doc;
				try {
					docBuilder = factory.newDocumentBuilder();
					doc = docBuilder.parse(fichier);

					// On a passe l'etape critique du build ; on sait maintenant
					// que le fichier est lisible. On peut incrementer le
					// compteur de documents, qui va servir d'idDocument dans
					// les noeuds
					idDocument++;
					documents.add(idDocument-1, new Docs(fichier.getName()));

					NodeList listTitres = doc.getElementsByTagName("TITRE");
					for (int idTitre = 0; idTitre < listTitres.getLength(); idTitre++) {
						Node titre = listTitres.item(idTitre);
						Node parent = titre.getParentNode();
						String xPathParent = getXPath(parent, idDocument);
						List<String> texteTitre = Lemmatiseur.decoupeChaine(titre.getTextContent(), false);
						mapTitres.put(xPathParent, texteTitre);
					}

					NodeList listSsTitres = doc
							.getElementsByTagName("SOUS-TITRE");
					for (int idSsTitre = 0; idSsTitre < listSsTitres
							.getLength(); idSsTitre++) {
						Node ssTitre = listSsTitres.item(idSsTitre);
						Node parent = ssTitre.getParentNode();
						String xPathParent = getXPath(parent, idDocument);
						List<String> texteSsTitre = Lemmatiseur.decoupeChaine(ssTitre.getTextContent(), false);
						mapSsTitres.put(xPathParent, texteSsTitre);
					}

					NodeList listP = doc.getElementsByTagName("P");

					for (int idP = 0; idP < listP.getLength(); idP++) {
						Node paragraphe = listP.item(idP);
						String xPath = getXPath(paragraphe, idDocument);
						Noeud noeud = Lemmatiseur.decomposeParagraphe(
								paragraphe.getTextContent(), termes,
								idDocument, xPath);
						noeuds.add(noeud);
					}

				} catch (IOException | SAXException
						| ParserConfigurationException e) {
					// Si la lecture du fichier echoue, on ne veut pas
					// interrompre toute la chaine
					// Le try n'englobe donc que le parsage de ce fichier
					System.err.println("Fichier illisible : "
							+ fichier.getAbsolutePath());
					e.printStackTrace();
				}
			}
		}

		// on va remplir la balade apres avoir fait les calculs.
		b.setDocuments(documents);
		b.setNoeuds(noeuds);
		b.setTermes(termes);
		b.setMapTitres(mapTitres);
		b.setMapSsTitres(mapSsTitres);

		// calcul du score (de idf et tf, etc...)
		for (Terme terme : termes) {
			Lemmatiseur.calculScore(terme, b);
		}

		// Fin
		return b;
	}

	

	

	

	

	private static String getXPath(Node node, int idDocument) {
		if (node.getNodeName().equals("BALADE")) {
			return "/BALADE[1]";
		}
		Node parent = node.getParentNode();
		int compteurJumeaux = 0;
		NodeList fratrie = parent.getChildNodes();
		for (int idFrere = 0; idFrere < fratrie.getLength(); idFrere++) {
			Node frere = fratrie.item(idFrere);
			// Si ce frere porte le meme nom, c'est un jumeau
			if (frere.getNodeName().equals(node.getNodeName())) {
				compteurJumeaux++;
			}
			// Et si en plus ils ont la meme adresse, alors... Ce n'est pas un
			// jumeau, c'est le noeud courant !
			if (frere == node) {
				break;
			}
		}
		return getXPath(parent, idDocument) + "/" + node.getNodeName() + "["
				+ compteurJumeaux + "]";
	}

	

	

	public static void main(String[] args) {
		Balade b = parseXmlToJava("ressources/Collection");
		 b.afficher();
		new RemplirBDD(b);
		System.out.println("ok");
	}
}
